import { http } from "@/utils/http";
import type { ArticleTagInfo } from "./article-tag";

/** 统一响应格式 */
export interface ApiResponse<T = any> {
  /** 状态码 */
  code: number;
  /** 响应消息 */
  message: string;
  /** 响应数据 */
  data?: T;
  /** 时间戳 */
  timestamp?: number;
}

/** 分页响应格式 */
export interface PageResponse<T> {
  /** 记录列表 */
  records: T[];
  /** 总记录数 */
  total: number;
  /** 当前页码 */
  current: number;
  /** 每页大小 */
  size: number;
  /** 总页数 */
  pages: number;
}

/** 文章状态枚举 */
export enum ArticleStatus {
  /** 草稿 */
  DRAFT = 0,
  /** 已发布 */
  PUBLISHED = 1,
  /** 已删除 */
  DELETED = 2,
  /** 待审核 */
  PENDING = 3,
  /** 审核拒绝 */
  REJECTED = 4,
  /** 已下架 */
  UNPUBLISHED = 5
}

/** 批量操作类型 */
export enum BatchOperationType {
  /** 审核通过 */
  APPROVE = "APPROVE",
  /** 审核拒绝 */
  REJECT = "REJECT",
  /** 发布 */
  PUBLISH = "PUBLISH",
  /** 下架 */
  UNPUBLISH = "UNPUBLISH",
  /** 置顶 */
  TOP = "TOP",
  /** 取消置顶 */
  UNTOP = "UNTOP",
  /** 删除 */
  DELETE = "DELETE",
  /** 恢复 */
  RESTORE = "RESTORE"
}

/** 文章列表查询参数 */
export interface ArticleListQuery {
  /** 当前页码 */
  current?: number;
  /** 每页大小 */
  size?: number;
  /** 文章标题关键词 */
  title?: string;
  /** 作者ID */
  authorId?: number;
  /** 作者用户名 */
  authorName?: string;
  /** 分类ID */
  categoryId?: number;
  /** 分类名称 */
  categoryName?: string;
  /** 文章状态 */
  status?: ArticleStatus;
  /** 是否置顶 */
  isTop?: number;
  /** 是否原创 */
  isOriginal?: number;
  /** 标签关键词（已废弃，兼容用） */
  tags?: string;
  /** 标签ID列表（新增：精确查询） */
  tagIds?: number[];
  /** 全文搜索关键词 */
  keyword?: string;
  /** 开始时间 */
  startTime?: string;
  /** 结束时间 */
  endTime?: string;
  /** 排序字段 */
  sortField?: string;
  /** 排序方向 */
  sortOrder?: "asc" | "desc";
  /** 最小浏览量 */
  minViewCount?: number;
  /** 最大浏览量 */
  maxViewCount?: number;
  /** 最小点赞数 */
  minLikeCount?: number;
  /** 最大点赞数 */
  maxLikeCount?: number;
}

/** 文章基本信息 */
export interface ArticleInfo {
  /** 文章ID */
  id: number;
  /** 文章标题 */
  title: string;
  /** 文章摘要 */
  summary: string;
  /** 封面图片 */
  coverImage?: string;
  /** 作者ID */
  authorId: number;
  /** 作者用户名 */
  authorName: string;
  /** 作者昵称 */
  authorNickName?: string;
  /** 作者头像 */
  authorAvatar?: string;
  /** 分类ID */
  categoryId: number;
  /** 分类名称 */
  categoryName: string;
  /** 文章标签（字符串格式，逗号分隔，已废弃） */
  tags: string;
  /** 标签详细信息（新增） */
  articleTags?: ArticleTagInfo[];
  /** 标签数量（新增） */
  tagCount?: number;
  /** 浏览量 */
  viewCount: number;
  /** 点赞数 */
  likeCount: number;
  /** 评论数 */
  commentCount: number;
  /** 收藏数 */
  collectCount: number;
  /** 分享数 */
  shareCount?: number;
  /** 是否原创（1: 原创, 0: 转载） */
  isOriginal: number;
  /** 是否置顶（1: 置顶, 0: 普通） */
  isTop: number;
  /** 文章状态 */
  status: ArticleStatus;
  /** 状态文本 */
  statusText: string;
  /** 发布时间 */
  publishTime: string;
  /** 创建时间 */
  createTime: string;
  /** 更新时间 */
  updateTime: string;
  /** 审核时间 */
  auditTime?: string | null;
  /** 审核用户ID */
  auditUserId?: number | null;
  /** 审核用户名 */
  auditUserName?: string | null;
  /** 审核备注 */
  auditRemark?: string | null;
  /** 字数统计 */
  wordCount: number;
  /** 阅读时长（分钟） */
  readingTime: number;
  /** 置顶文本 */
  topText?: string;
  /** 原创文本 */
  originalText?: string;
}

/** 文章详情信息 */
export interface ArticleDetail extends ArticleInfo {
  /** Markdown内容 */
  content: string;
  /** HTML内容 */
  htmlContent: string;
  /** 审核原因 */
  auditReason?: string | null;
  /** 是否已发布 */
  published?: boolean;
  /** 是否可审核 */
  auditable?: boolean;
  /** 是否已删除 */
  deleted?: boolean;
  /** 是否可编辑 */
  editable?: boolean;
  /** 目录信息 */
  tableOfContents?: string;
  /** 是否包含代码块 */
  hasCodeBlock?: boolean;
  /** 是否包含图片 */
  hasImage?: boolean;
  /** 是否包含表格 */
  hasTable?: boolean;
  /** 是否包含数学公式 */
  hasMath?: boolean;
}

/** 文章审核参数 */
export interface ArticleAuditParams {
  /** 文章ID */
  articleId: number;
  /** 审核结果 */
  auditResult: 1 | 4;
  /** 审核备注 */
  auditRemark?: string;
  /** 审核原因 */
  auditReason?: string;
  /** 是否发送通知 */
  sendNotification?: boolean;
  /** 建议 */
  suggestions?: string;
}

/** 批量操作参数 */
export interface BatchOperationParams {
  /** 文章ID列表 */
  articleIds: number[];
  /** 操作类型 */
  operationType: BatchOperationType;
  /** 备注 */
  remark?: string;
  /** 原因 */
  reason?: string;
  /** 是否发送通知 */
  sendNotification?: boolean;
}

/** 文章统计信息 */
export interface ArticleStatistics {
  /** 总文章数 */
  total_count: number;
  /** 已发布数量 */
  published_count: number;
  /** 草稿数量 */
  draft_count: number;
  /** 待审核数量 */
  pending_count: number;
  /** 审核拒绝数量 */
  rejected_count: number;
  /** 已删除数量 */
  deleted_count: number;
  /** 已下架数量 */
  unpublished_count: number;
  /** 置顶数量 */
  top_count: number;
  /** 总浏览量 */
  total_views: number;
  /** 总点赞数 */
  total_likes: number;
  /** 总评论数 */
  total_comments: number;
  /** 总收藏数 */
  total_collects: number;
}

/** Markdown预览参数 */
export interface MarkdownPreviewParams {
  /** Markdown内容 */
  content: string;
  /** 启用代码高亮 */
  enableCodeHighlight?: boolean;
  /** 启用数学公式 */
  enableMath?: boolean;
  /** 启用表格 */
  enableTable?: boolean;
  /** 启用任务列表 */
  enableTaskList?: boolean;
  /** 启用删除线 */
  enableStrikethrough?: boolean;
  /** 启用自动链接 */
  enableAutolink?: boolean;
  /** 主题 */
  theme?: string;
}

/** Markdown预览结果 */
export interface MarkdownPreviewResult {
  /** Markdown内容 */
  markdownContent: string;
  /** HTML内容 */
  htmlContent: string;
  /** 字数统计 */
  wordCount: number;
  /** 阅读时长 */
  readingTime: number;
  /** 目录 */
  tableOfContents: string;
  /** 是否包含代码块 */
  hasCodeBlock: boolean;
  /** 是否包含图片 */
  hasImage: boolean;
  /** 是否包含表格 */
  hasTable: boolean;
  /** 是否包含数学公式 */
  hasMath: boolean;
  /** 处理时间 */
  processTime: number;
}

/** 批量处理参数 */
export interface BatchProcessParams {
  /** Markdown内容 */
  markdownContent: string;
  /** 转换为HTML */
  convertToHtml?: boolean;
  /** 提取目录 */
  extractToc?: boolean;
  /** 计算字数 */
  calculateWordCount?: boolean;
  /** 生成摘要 */
  generateSummary?: boolean;
  /** 摘要最大长度 */
  summaryMaxLength?: number;
}

// ==================== API 接口函数 ====================

/** 分页查询文章列表 */
export const getArticleListApi = (params: ArticleListQuery) => {
  // 兼容两种响应格式：标准格式和直接分页格式
  return http.request<
    ApiResponse<PageResponse<ArticleInfo>> | PageResponse<ArticleInfo>
  >("get", "/admin/articles/list", { params });
};

/** 获取文章详情 */
export const getArticleDetailApi = (articleId: number) => {
  return http.request<ApiResponse<ArticleDetail>>(
    "get",
    `/admin/articles/${articleId}`
  );
};

/** 审核文章 */
export const auditArticleApi = (params: ArticleAuditParams) => {
  return http.request<ApiResponse>("post", "/admin/articles/audit", {
    data: params
  });
};

/** 获取待审核文章数量 */
export const getPendingAuditCountApi = () => {
  return http.request<ApiResponse<number>>(
    "get",
    "/admin/articles/pending-audit-count"
  );
};

/** 获取文章状态分布 */
export const getArticleStatusDistributionApi = () => {
  return http.request<ApiResponse<Record<string, number>>>(
    "get",
    "/admin/articles/status-distribution"
  );
};

/** 批量操作文章 */
export const batchOperateArticlesApi = (params: BatchOperationParams) => {
  return http.request<ApiResponse>("post", "/admin/articles/batch", {
    data: params
  });
};

/** 发布文章 */
export const publishArticleApi = (articleId: number) => {
  return http.request<ApiResponse>(
    "post",
    `/admin/articles/${articleId}/publish`
  );
};

/** 下架文章 */
export const unpublishArticleApi = (articleId: number, reason?: string) => {
  const params = reason ? { reason } : {};
  return http.request<ApiResponse>(
    "post",
    `/admin/articles/${articleId}/unpublish`,
    { params }
  );
};

/** 置顶/取消置顶文章 */
export const toggleTopArticleApi = (articleId: number, isTop: boolean) => {
  return http.request<ApiResponse>("post", `/admin/articles/${articleId}/top`, {
    params: { isTop }
  });
};

/** 删除文章 */
export const deleteArticleApi = (articleId: number) => {
  return http.request<ApiResponse>("delete", `/admin/articles/${articleId}`);
};

/** 恢复文章 */
export const restoreArticleApi = (articleId: number) => {
  return http.request<ApiResponse>(
    "post",
    `/admin/articles/${articleId}/restore`
  );
};

/** 获取文章统计信息 */
export const getArticleStatisticsApi = () => {
  // 兼容两种响应格式：标准格式和直接统计格式
  return http.request<ApiResponse<ArticleStatistics> | ArticleStatistics>(
    "get",
    "/admin/articles/statistics"
  );
};

/** 获取热门文章 */
export const getPopularArticlesApi = (limit: number = 10) => {
  return http.request<ApiResponse<ArticleInfo[]>>(
    "get",
    "/admin/articles/popular",
    {
      params: { limit }
    }
  );
};

/** 获取最新文章 */
export const getLatestArticlesApi = (limit: number = 10) => {
  return http.request<ApiResponse<ArticleInfo[]>>(
    "get",
    "/admin/articles/latest",
    {
      params: { limit }
    }
  );
};

/** 搜索文章 */
export const searchArticlesApi = (
  keyword: string,
  current: number = 1,
  size: number = 10
) => {
  return http.request<ApiResponse<PageResponse<ArticleInfo>>>(
    "get",
    "/admin/articles/search",
    {
      params: { keyword, current, size }
    }
  );
};

/** 获取用户文章 */
export const getUserArticlesApi = (
  userId: number,
  current: number = 1,
  size: number = 10
) => {
  return http.request<ApiResponse<PageResponse<ArticleInfo>>>(
    "get",
    `/admin/articles/user/${userId}`,
    {
      params: { current, size }
    }
  );
};

/** 获取分类文章 */
export const getCategoryArticlesApi = (
  categoryId: number,
  current: number = 1,
  size: number = 10
) => {
  return http.request<ApiResponse<PageResponse<ArticleInfo>>>(
    "get",
    `/admin/articles/category/${categoryId}`,
    {
      params: { current, size }
    }
  );
};

// ==================== Markdown 预览接口 ====================

/** Markdown预览 */
export const previewMarkdownApi = (params: MarkdownPreviewParams) => {
  return http.request<ApiResponse<MarkdownPreviewResult>>(
    "post",
    "/api/markdown/preview",
    { data: params }
  );
};

/** Markdown转HTML */
export const convertMarkdownToHtmlApi = (content: string) => {
  return http.request<ApiResponse<string>>("post", "/api/markdown/convert", {
    data: content,
    headers: { "Content-Type": "text/plain" }
  });
};

/** 提取目录 */
export const extractTableOfContentsApi = (content: string) => {
  return http.request<ApiResponse<string>>("post", "/api/markdown/toc", {
    data: content,
    headers: { "Content-Type": "text/plain" }
  });
};

/** 计算字数 */
export const calculateWordCountApi = (content: string) => {
  return http.request<ApiResponse<number>>("post", "/api/markdown/word-count", {
    data: content,
    headers: { "Content-Type": "text/plain" }
  });
};

/** 生成摘要 */
export const generateSummaryApi = (
  content: string,
  maxLength: number = 200
) => {
  return http.request<ApiResponse<string>>("post", "/api/markdown/summary", {
    data: content,
    params: { maxLength },
    headers: { "Content-Type": "text/plain" }
  });
};

/** 批量处理 */
export const batchProcessMarkdownApi = (params: BatchProcessParams) => {
  return http.request<ApiResponse<any>>("post", "/api/markdown/batch-process", {
    data: params
  });
};

// ==================== 工具函数 ====================

/** 文章管理工具类 */
export class ArticleManagementUtils {
  /** 获取文章状态文本 */
  static getStatusText(status: ArticleStatus): string {
    const statusMap = {
      [ArticleStatus.DRAFT]: "草稿",
      [ArticleStatus.PUBLISHED]: "已发布",
      [ArticleStatus.DELETED]: "已删除",
      [ArticleStatus.PENDING]: "待审核",
      [ArticleStatus.REJECTED]: "审核拒绝",
      [ArticleStatus.UNPUBLISHED]: "已下架"
    };
    return statusMap[status] || "未知状态";
  }

  /** 获取状态标签类型 */
  static getStatusTagType(status: ArticleStatus | undefined | null): string {
    // 处理空值情况
    if (status === undefined || status === null) {
      return "info";
    }
    const typeMap = {
      [ArticleStatus.DRAFT]: "info",
      [ArticleStatus.PUBLISHED]: "success",
      [ArticleStatus.DELETED]: "danger",
      [ArticleStatus.PENDING]: "warning",
      [ArticleStatus.REJECTED]: "danger",
      [ArticleStatus.UNPUBLISHED]: "warning"
    };
    return typeMap[status] || "info";
  }

  /** 获取批量操作类型文本 */
  static getBatchOperationText(type: BatchOperationType): string {
    const textMap = {
      [BatchOperationType.APPROVE]: "审核通过",
      [BatchOperationType.REJECT]: "审核拒绝",
      [BatchOperationType.PUBLISH]: "发布",
      [BatchOperationType.UNPUBLISH]: "下架",
      [BatchOperationType.TOP]: "置顶",
      [BatchOperationType.UNTOP]: "取消置顶",
      [BatchOperationType.DELETE]: "删除",
      [BatchOperationType.RESTORE]: "恢复"
    };
    return textMap[type] || "未知操作";
  }

  /** 格式化数字 */
  static formatNumber(num: number): string {
    if (num >= 10000) {
      return (num / 10000).toFixed(1) + "万";
    } else if (num >= 1000) {
      return (num / 1000).toFixed(1) + "k";
    }
    return num.toString();
  }

  /** 格式化时间 */
  static formatTime(time: string): string {
    if (!time) return "-";
    const date = new Date(time);
    const now = new Date();
    const diff = now.getTime() - date.getTime();

    const minute = 60 * 1000;
    const hour = 60 * minute;
    const day = 24 * hour;
    const month = 30 * day;

    if (diff < minute) {
      return "刚刚";
    } else if (diff < hour) {
      return Math.floor(diff / minute) + "分钟前";
    } else if (diff < day) {
      return Math.floor(diff / hour) + "小时前";
    } else if (diff < month) {
      return Math.floor(diff / day) + "天前";
    } else {
      return date.toLocaleDateString();
    }
  }

  /** 计算阅读时长 */
  static calculateReadingTime(wordCount: number): number {
    // 假设每分钟阅读200字
    return Math.ceil(wordCount / 200);
  }

  /** 截取摘要 */
  static truncateSummary(content: string, maxLength: number = 100): string {
    if (!content) return "";
    if (content.length <= maxLength) return content;
    return content.substring(0, maxLength) + "...";
  }

  /** 验证文章数据 */
  static validateArticleData(article: Partial<ArticleInfo>): string[] {
    const errors: string[] = [];

    if (!article.title?.trim()) {
      errors.push("文章标题不能为空");
    } else if (article.title.length > 100) {
      errors.push("文章标题不能超过100个字符");
    }

    if (!article.summary?.trim()) {
      errors.push("文章摘要不能为空");
    } else if (article.summary.length > 500) {
      errors.push("文章摘要不能超过500个字符");
    }

    if (!article.categoryId) {
      errors.push("请选择文章分类");
    }

    return errors;
  }

  /** 获取可用的批量操作 */
  static getAvailableBatchOperations(
    selectedStatuses: ArticleStatus[]
  ): BatchOperationType[] {
    const operations: BatchOperationType[] = [];

    // 如果包含待审核状态，可以审核通过或拒绝
    if (selectedStatuses.includes(ArticleStatus.PENDING)) {
      operations.push(BatchOperationType.APPROVE, BatchOperationType.REJECT);
    }

    // 如果包含已发布状态，可以下架
    if (selectedStatuses.includes(ArticleStatus.PUBLISHED)) {
      operations.push(
        BatchOperationType.UNPUBLISH,
        BatchOperationType.TOP,
        BatchOperationType.UNTOP
      );
    }

    // 如果包含草稿或审核通过状态，可以发布
    if (
      selectedStatuses.some(s =>
        [ArticleStatus.DRAFT, ArticleStatus.REJECTED].includes(s)
      )
    ) {
      operations.push(BatchOperationType.PUBLISH);
    }

    // 如果包含已删除状态，可以恢复
    if (selectedStatuses.includes(ArticleStatus.DELETED)) {
      operations.push(BatchOperationType.RESTORE);
    }

    // 删除操作总是可用（除了已删除状态）
    if (!selectedStatuses.every(s => s === ArticleStatus.DELETED)) {
      operations.push(BatchOperationType.DELETE);
    }

    return [...new Set(operations)]; // 去重
  }

  /** 检查操作权限 */
  static checkOperationPermission(
    status: ArticleStatus,
    operation: string
  ): boolean {
    const permissions = {
      [ArticleStatus.DRAFT]: ["publish", "delete", "edit"],
      [ArticleStatus.PUBLISHED]: [
        "unpublish",
        "top",
        "untop",
        "delete",
        "edit"
      ],
      [ArticleStatus.DELETED]: ["restore"],
      [ArticleStatus.PENDING]: ["approve", "reject", "delete"],
      [ArticleStatus.REJECTED]: ["publish", "delete", "edit"],
      [ArticleStatus.UNPUBLISHED]: ["publish", "delete", "edit"]
    };

    return permissions[status]?.includes(operation) || false;
  }

  /** 解析标签字符串为数组 */
  static parseTagsString(tags: string): string[] {
    if (!tags || typeof tags !== "string") return [];
    return tags
      .split(",")
      .map(tag => tag.trim())
      .filter(tag => tag.length > 0);
  }

  /** 将标签数组转换为字符串 */
  static stringifyTags(tags: string[]): string {
    if (!Array.isArray(tags)) return "";
    return tags.join(",");
  }
}
